/**
 * 深拷贝对象或数组，使用迭代方式避免栈溢出
 * @description 支持处理循环引用、特殊对象类型（Date、RegExp等），并使用迭代方式避免深层对象导致的栈溢出
 * @template T - 要克隆的对象类型
 * @param {T} value - 要克隆的值
 * @returns {T} 深度克隆后的值
 * @example
 * // 基础类型
 * deepClone(42); // 42
 * deepClone("text"); // "text"
 *
 * // 数组和对象
 * const obj = { a: [1, { b: 2 }], c: new Date() };
 * const cloned = deepClone(obj);
 *
 * // 循环引用
 * const circular = { a: 1 };
 * circular.self = circular;
 * const clonedCircular = deepClone(circular); // 正确处理循环引用
 */
const deepClone = (value) => {
    // 处理特殊对象的克隆
    const cloneSpecialObject = (obj) => {
        if (obj instanceof Date)
            return new Date(obj);
        if (obj instanceof RegExp)
            return new RegExp(obj);
        if (obj instanceof Map) {
            const clonedMap = new Map();
            for (const [key, val] of obj) {
                clonedMap.set(key, deepClone(val));
            }
            return clonedMap;
        }
        if (obj instanceof Set) {
            const clonedSet = new Set();
            for (const val of obj) {
                clonedSet.add(deepClone(val));
            }
            return clonedSet;
        }
        return null; // 不是特殊对象
    };
    // 使用 WeakMap 存储已克隆的对象，处理循环引用
    const cloneMap = new WeakMap();
    // 迭代方式实现深拷贝
    const deepCloneIterative = (val) => {
        // 处理基础类型和 null
        if (val === null || typeof val !== 'object') {
            return val;
        }
        // 检查循环引用
        if (cloneMap.has(val)) {
            return cloneMap.get(val);
        }
        // 检查特殊对象类型
        const specialObject = cloneSpecialObject(val);
        if (specialObject !== null) {
            return specialObject;
        }
        // 创建新的数组或对象
        const clone = Array.isArray(val) ? [] : {};
        // 将新创建的对象添加到 cloneMap
        cloneMap.set(val, clone);
        // 使用栈存储待处理的项
        const stack = [
            { target: clone, source: val }
        ];
        // 迭代处理所有嵌套属性
        while (stack.length > 0) {
            const { target, source } = stack.pop();
            // 获取所有可枚举属性，包括 Symbol
            const keys = [
                ...Object.getOwnPropertyNames(source),
                ...Object.getOwnPropertySymbols(source)
            ];
            for (const key of keys) {
                const sourceVal = source[key];
                if (sourceVal === null || typeof sourceVal !== 'object') {
                    // 基础类型直接赋值
                    target[key] = sourceVal;
                }
                else {
                    // 检查是否已经克隆过
                    if (cloneMap.has(sourceVal)) {
                        target[key] = cloneMap.get(sourceVal);
                        continue;
                    }
                    // 检查特殊对象类型
                    const specialVal = cloneSpecialObject(sourceVal);
                    if (specialVal !== null) {
                        target[key] = specialVal;
                        continue;
                    }
                    // 创建新的嵌套对象或数组
                    const newTarget = Array.isArray(sourceVal) ? [] : {};
                    target[key] = newTarget;
                    cloneMap.set(sourceVal, newTarget);
                    // 将嵌套对象添加到栈中等待处理
                    stack.push({ target: newTarget, source: sourceVal });
                }
            }
        }
        return clone;
    };
    return deepCloneIterative(value);
};

export { deepClone };
